//package com.zmn.plat.business.impl.oneprice;
//
//import java.lang.reflect.Field;
//import java.util.*;
//import java.util.stream.Collectors;
//
//import javax.annotation.Resource;
//
//import org.slf4j.Logger;
//import org.slf4j.LoggerFactory;
//import org.springframework.beans.factory.annotation.Autowired;
//import org.springframework.cache.annotation.Cacheable;
//import org.springframework.stereotype.Service;
//import org.springframework.transaction.annotation.Transactional;
//import org.springframework.util.CollectionUtils;
//
//import com.google.common.collect.Lists;
//import com.google.common.collect.Maps;
//import com.zmn.common.constant.GlobalConsts;
//import com.zmn.common.dictionary.GlobalDict;
//import com.zmn.common.utils.date.DateUtil;
//import com.zmn.common.utils.number.NumberUtil;
//import com.zmn.common.utils.reflect.BeanMapper;
//import com.zmn.common.utils.string.StringUtil;
//import com.zmn.mcc.cas.model.LoginStaff;
//import com.zmn.plat.business.interfaces.oneprice.ChannelPriceBService;
//import com.zmn.plat.business.interfaces.product.ProductBService;
//import com.zmn.plat.common.constant.OnePriceConsts;
//import com.zmn.plat.common.constant.ProductConsts;
//import com.zmn.plat.common.dictionary.PlatErrorCodeDict;
//import com.zmn.plat.common.exception.PlatException;
//import com.zmn.plat.manager.dictionary.ChannelDict;
//import com.zmn.plat.manager.dictionary.OnePriceDict;
//import com.zmn.plat.manager.dictionary.ProductDict;
//import com.zmn.plat.model.entity.area.BaseArea;
//import com.zmn.plat.model.entity.category.BaseCategory;
//import com.zmn.plat.model.entity.category.BaseCategoryQuery;
//import com.zmn.plat.model.entity.channel.Channel;
//import com.zmn.plat.model.entity.channel.ChannelServiceArea;
//import com.zmn.plat.model.entity.oneprice.*;
//import com.zmn.plat.model.entity.product.ServProduct;
//import com.zmn.plat.model.entity.product.ServProductQuery;
//import com.zmn.plat.model.entity.product.ServProductRelation;
//import com.zmn.plat.model.entity.servcategory.ServAssCategoryQuery;
//import com.zmn.plat.model.entity.servcategory.ServCategory;
//import com.zmn.plat.model.entity.servcategory.ShowCategoryAssociation;
//import com.zmn.plat.model.vo.servcategory.ServAssCategoryVO;
//import com.zmn.plat.services.interfaces.area.BaseAreaService;
//import com.zmn.plat.services.interfaces.category.BaseCategoryService;
//import com.zmn.plat.services.interfaces.channel.ChannelService;
//import com.zmn.plat.services.interfaces.channel.ChannelServiceAreaService;
//import com.zmn.plat.services.interfaces.oneprice.*;
//import com.zmn.plat.services.interfaces.product.ServProductRelationService;
//import com.zmn.plat.services.interfaces.product.ServProductService;
//import com.zmn.plat.services.interfaces.servcategory.ServAssCategoryService;
//import com.zmn.plat.services.interfaces.servcategory.ServCategoryService;
//import com.zmn.plat.services.interfaces.servcategory.ShowCategoryAssociationService;
//
///**
// * ChannelPriceServiceImpl
// *
// * @author tanghongjun
// * @updater wangjie 2019-07-07
// * @since 18/10/15 11:09
// */
//@Service
//public class ChannelPriceBServiceImpl implements ChannelPriceBService {
//
//    @Resource
//    protected BaseAreaService baseAreaService;
//
//    @Resource
//    protected ChannelService channelService;
//
//    @Resource
//    protected ChannelServiceAreaService channelServiceAreaService;
//
//    @Resource
//    ChannelPriceService channelPriceService;
//
//    @Resource
//    ChannelPriceLogService channelPriceLogService;
//
//    @Resource
//    ChannelPriceCityService channelPriceCityService;
//
//    @Resource
//    ServCityPriceService servCityPriceService;
//
//    @Resource
//    ChannelPriceServService channelPriceServService;
//
//    @Resource
//    ChannelPriceCategoryService channelPriceCategoryService;
//
//    @Resource
//    ServProductService servProductService;
//
//    @Resource
//    BaseCategoryService baseCategoryService;
//
//    @Resource
//    ServCategoryService servCategoryService;
//
//    @Resource
//    ServProductRelationService servProductRelationService;
//
//
//    @Autowired
//    private ServAssCategoryService servAssCategoryService;
//
//    @Autowired
//    private ShowCategoryAssociationService showCategoryAssociationService;
//    @Autowired
//    private ProductBService productBService;
//
//    private Logger logger = LoggerFactory.getLogger(ChannelPriceBServiceImpl.class);
//
//    @Override
//    public List<BaseArea> findByChannelId(Integer channelId) {
//        Channel channel = channelService.findByKey(channelId);
//        List<BaseArea> baseAreaList;
//        if (channel.getScope().equals(ChannelDict.SCOPE_ALL)) {
//            baseAreaList = baseAreaService.listByParentId(GlobalConsts.TOP_ID);
//            return baseAreaList;
//        } else {
//            List<ChannelServiceArea> channelServAreaList = channelServiceAreaService.listByChannelId(channelId);
//            if (CollectionUtils.isEmpty(channelServAreaList)) {
//                return Collections.emptyList();
//            }
//            List<Integer> cityIdList = channelServAreaList.stream().map(ChannelServiceArea::getCityId).distinct().collect(Collectors.toList());
//            List<BaseArea> cityList = baseAreaService.findByKeys(cityIdList);
//            if (CollectionUtils.isEmpty(cityList)) {
//                return Collections.emptyList();
//            }
//            List<Integer> provinceIdList = cityList.stream().map(BaseArea::getParentId).distinct().collect(Collectors.toList());
//            baseAreaList = baseAreaService.findByKeys(provinceIdList);
//            return baseAreaList;
//        }
//    }
//
//    @Override
//    public List<SupportTariffCategoryVO> listSupportTariffCategory(Integer channelId, Integer cityId, List<Integer> servCategIds, List<Integer> categIds) {
//        return channelPriceService.listSupportTariffCategory(channelId, cityId, servCategIds, categIds);
//    }
//
//    @Override
//    public List<SupportTariffCategoryVO> listSupportTariffByChannelIdAndCityIdAndCategIds(Integer channelId, Integer cityId, List<ChannelPriceSupportCategoryQuery> queryList) {
//        if(NumberUtil.isNullOrZero(channelId)||NumberUtil.isNullOrZero(cityId)||CollectionUtils.isEmpty(queryList)){
//            throw new PlatException(PlatErrorCodeDict.ERROR_CODE_PANAM_NULL);
//        }
//        BaseArea area = baseAreaService.findByKey(cityId);
//        if(Objects.isNull(area)){
//            logger.error("cityId 对应的区域数据不存在");
//            throw new PlatException(PlatErrorCodeDict.ERROR_CODE_AREA_NOT_EXIST);
//        }
//
//        //1.渠道层面
//        // 渠道是否配置试点，存在数据状态为开启，类型为计价器试点
//        ChannelPriceQuery query = new ChannelPriceQuery();
//        query.setChannelId(channelId);
//        query.setStatus(GlobalConsts.YES);
//        query.setType(GlobalConsts.YES);
//        List<ChannelPrice> channelPriceList = channelPriceService.listByQuery(query);
//
//        // 渠道没开通试点，查询城市是否开通试点
//        if(CollectionUtils.isEmpty(channelPriceList)){
//            return listSupportTariffByCityIdAndCategIds(cityId,queryList);
//        }
//
//        List<Integer> priceRelationIdList = channelPriceList.stream().map(e->e.getChannelPriceId()).collect(Collectors.toList());
//        //查询城市是否在渠道配置的执行和不执行城市中
//        List<ChannelPriceCity> channelPriceCityList = channelPriceCityService.listByChannelPriceIdList(priceRelationIdList);
//
//        // 未配置渠道执行城市维度，走城市维度
//        if(CollectionUtils.isEmpty(channelPriceCityList)){
//            return listSupportTariffByCityIdAndCategIds(cityId,queryList);
//        }
//
//        List<ChannelPriceCity> matchCityList = channelPriceCityList.stream().filter(e->Objects.equals(e.getCityId(),cityId)
//                ||(Objects.equals(e.getProvinceId(),area.getParentId())&&Objects.isNull(e.getCityId()))).collect(Collectors.toList());
//        // 当前参数在渠道维度未配置，走城市维度
//        if(CollectionUtils.isEmpty(matchCityList)){
//            return listSupportTariffByCityIdAndCategIds(cityId,queryList);
//        }
//
//        //命中不执行城市，那么不支持试点
//        boolean isNotSupportCity = matchCityList.stream().anyMatch(e->Objects.equals(e.getType(),OnePriceConsts.NOT_SUPPORT_CITY));
//        if(isNotSupportCity){
//            return Lists.newArrayList();
//        }
//        // 命中执行城市，再次判断分类是否满足
//        List<Integer> priceRelationSupportIds = matchCityList.stream().filter(e->Objects.equals(e.getType(),OnePriceConsts.SUPPORT_CITY)).map(e->e.getChannelPriceId()).collect(Collectors.toList());
//        if(!CollectionUtils.isEmpty(priceRelationSupportIds)){
//            // 分类是否满足试点要求
//            return listSupportTariffCategoryByConfigIdsAndCategIds(GlobalConsts.NO,priceRelationSupportIds,queryList);
//        }
//
//        // 配置的数据都没有命中，执行城市维度
//        return listSupportTariffByCityIdAndCategIds(cityId,queryList);
//    }
//
//    @Override
//    @Cacheable(cacheNames = "redis5m", key = "'channel:support:channel:'+#p0+':city:'+#p1", unless = "#result == null")
//    public List<SupportTariffCategoryVO> listSupportTariffByChannelIdAndCityId(Integer channelId, Integer cityId) {
//        if(NumberUtil.isNullOrZero(channelId)||NumberUtil.isNullOrZero(cityId)){
//            throw new PlatException(PlatErrorCodeDict.ERROR_CODE_PANAM_NULL);
//        }
//        BaseArea area = baseAreaService.findByKey(cityId);
//        if(Objects.isNull(area)){
//            logger.error("cityId 对应的区域数据不存在");
//            throw new PlatException(PlatErrorCodeDict.ERROR_CODE_AREA_NOT_EXIST);
//        }
//
//        //1.渠道层面
//        // 渠道是否配置试点，存在数据状态为开启，类型为计价器试点
//        ChannelPriceQuery query = new ChannelPriceQuery();
//        query.setChannelId(channelId);
//        query.setStatus(GlobalConsts.YES);
//        query.setType(GlobalConsts.YES);
//        List<ChannelPrice> channelPriceList = channelPriceService.listByQuery(query);
//
//        // 渠道没开通试点，查询城市是否开通试点
//        if(CollectionUtils.isEmpty(channelPriceList)){
//            return listSupportTariffByCityId(cityId);
//        }
//
//        List<Integer> priceRelationIdList = channelPriceList.stream().map(e->e.getChannelPriceId()).collect(Collectors.toList());
//        //查询城市是否在渠道配置的执行和不执行城市中
//        List<ChannelPriceCity> channelPriceCityList = channelPriceCityService.listByChannelPriceIdList(priceRelationIdList);
//
//        // 未配置渠道执行城市维度，走城市维度
//        if(CollectionUtils.isEmpty(channelPriceCityList)){
//            return listSupportTariffByCityId(cityId);
//        }
//
//        List<ChannelPriceCity> matchCityList = channelPriceCityList.stream().filter(e->Objects.equals(e.getCityId(),cityId)
//                ||(Objects.equals(e.getProvinceId(),area.getParentId())&&Objects.isNull(e.getCityId()))).collect(Collectors.toList());
//        // 当前参数在渠道维度未配置，走城市维度
//        if(CollectionUtils.isEmpty(matchCityList)){
//            return listSupportTariffByCityId(cityId);
//        }
//
//        //命中不执行城市，那么不支持试点
//        boolean isNotSupportCity = matchCityList.stream().anyMatch(e->Objects.equals(e.getType(),OnePriceConsts.NOT_SUPPORT_CITY));
//        if(isNotSupportCity){
//            return Lists.newArrayList();
//        }
//        // 命中执行城市，再次判断分类是否满足
//        List<Integer> priceRelationSupportIds = matchCityList.stream().filter(e->Objects.equals(e.getType(),OnePriceConsts.SUPPORT_CITY)).map(e->e.getChannelPriceId()).collect(Collectors.toList());
//        if(!CollectionUtils.isEmpty(priceRelationSupportIds)){
//            // 分类是否满足试点要求
//            return listSupportTariffCategoryByConfigIds(GlobalConsts.NO,priceRelationSupportIds);
//        }
//
//        // 配置的数据都没有命中，执行城市维度
//        return listSupportTariffByCityId(cityId);
//    }
//
//
//
//    @Override
//    public boolean getSupportByChannelIdAndCityIdAndType(Integer channelId, Integer cityId, Integer type) {
//        if (NumberUtil.isNullOrZero(channelId) || NumberUtil.isNullOrZero(cityId) || NumberUtil.isNullOrZero(type)) {
//            logger.error("渠道ID和城市ID和类型不能为空");
//            throw new PlatException(PlatErrorCodeDict.ERROR_CODE_PANAM_NULL);
//        }
//
//        BaseArea baseArea = Optional.ofNullable(baseAreaService.findByKey(cityId)).orElse(new BaseArea());
//        // 查询该渠道当前城市是否配置
//        List<ChannelPriceCity> channelPriceCityList = channelPriceCityService.listByChannelAndCityIdAndType(channelId, baseArea.getParentId(), cityId, type);
//        if (CollectionUtils.isEmpty(channelPriceCityList)) {
//            // 如果渠道没有配置，看城市是否配置
//            List<ServCityPrice> cityPriceList = servCityPriceService.listByCityIdAndType(cityId, type);
//            return !CollectionUtils.isEmpty(cityPriceList);
//        } else {
//            // 如果渠道配置，是否执行城市
//            return channelPriceCityList.get(0).getType() == OnePriceConsts.SUPPORT_CITY;
//        }
//    }
//
//    @Override
//    // @Cacheable(key = "'dubbo:channel:support:tariff:channelId:' + #p0 + ':city:' + #p1 + ':type:' + #p2 + ':servCategId:' + #p3 +
//    // ':categId:' + #p4",cacheNames = "redis1h")
//    public boolean getSupportByChannelIdAndCityIdAndTypeAndCategId(Integer channelId, Integer cityId, Integer type, Integer servCategId, Integer categId) {
//        if (NumberUtil.isNullOrZero(channelId) || NumberUtil.isNullOrZero(cityId) || NumberUtil.isNullOrZero(type) || NumberUtil.isNullOrZero(servCategId) || NumberUtil.isNullOrZero(categId)) {
//            logger.error("渠道ID，城市ID，类型，服务分类ID，二级分类ID不能为空");
//            throw new PlatException(PlatErrorCodeDict.ERROR_CODE_PANAM_NULL);
//        }
//        BaseArea baseArea = Optional.ofNullable(baseAreaService.findByKey(cityId)).orElse(new BaseArea());
//        // 查询该渠道当前城市是否配置
//        List<ChannelPriceCity> channelPriceCityList = channelPriceCityService.listByChannelAndCityIdAndType(channelId, baseArea.getParentId(), cityId, type);
//        if (CollectionUtils.isEmpty(channelPriceCityList)) {
//            // 如果渠道没有配置，看城市是否配置
//            List<ServCityPrice> cityPriceList = servCityPriceService.listByCityIdAndType(cityId, type);
//            if (!CollectionUtils.isEmpty(cityPriceList)) {
//                // 如果城市配置，看是否支持分类
//                ServCityPrice servCityPrice = cityPriceList.get(GlobalConsts.NONE);
//                List<ChannelPriceCategory> categoryList = channelPriceCategoryService.listByConfigIdAndTypeAndShowTypeAndCategId(servCityPrice.getRelationId(), OnePriceConsts.CITY_TYPE,
//                    ProductConsts.EC_PRODUCT_TYPE, servCategId, categId);
//                return !CollectionUtils.isEmpty(categoryList);
//            }
//            return false;
//        } else {
//            // 如果渠道配置，是否执行城市
//            ChannelPriceCity channelPriceCity = channelPriceCityList.get(GlobalConsts.NONE);
//            if (channelPriceCity.getType() == OnePriceConsts.SUPPORT_CITY) {
//                // 如果执行城市，是否支持分类
//                List<ChannelPriceCategory> categoryList = channelPriceCategoryService.listByConfigIdAndTypeAndShowTypeAndCategId(channelPriceCity.getChannelPriceId(), OnePriceConsts.CHANNEL_TYPE,
//                    ProductConsts.EC_PRODUCT_TYPE, servCategId, categId);
//                return !CollectionUtils.isEmpty(categoryList);
//            }
//            return false;
//        }
//    }
//
//    @Override
//    public boolean getSupportByChannelIdAndCityIdAndTypeAndProductId(Integer channelId, Integer cityId, Integer type, Integer productId, Integer showProductId) {
//        if (NumberUtil.isNullOrZero(channelId) || NumberUtil.isNullOrZero(cityId) || NumberUtil.isNullOrZero(type) || NumberUtil.isNullOrZero(showProductId)) {
//            logger.error("渠道ID，城市ID，类型，前台产品ID不能为空");
//            throw new PlatException(PlatErrorCodeDict.ERROR_CODE_PANAM_NULL);
//        }
//
//        ServProduct showProduct = servProductService.findByKey(showProductId);
//        // 前台产品是否支持计价器
//        if (Objects.isNull(showProduct)) {
//            logger.error("=========== getSupportByChannelIdAndCityIdAndTypeAndProductId前台产品不存在，请检查参数,errorCode:{}", PlatErrorCodeDict.ERROR_CODE_SHOW_PRODUCT_NOT_EXIST);
//            throw new PlatException(PlatErrorCodeDict.ERROR_CODE_SHOW_PRODUCT_NOT_EXIST);
//        }
//
//        Integer servCategId = showProduct.getServCategId();
//        Integer categId = showProduct.getCategId();
//        boolean isSupport = this.getSupportByChannelIdAndCityIdAndTypeAndCategId(channelId, cityId, type, servCategId, categId);
//        if (!isSupport) {
//            logger.warn("=========== getSupportByChannelIdAndCityIdAndTypeAndProductId 未配置计价器试点，不支持计价器");
//            return false;
//        }
//        if (!NumberUtil.isNullOrZero(productId)) {
//            isSupport = productBService.checkTariffByProductIdAndShowType(productId, channelId, ProductConsts.ERP_PRODUCT_TYPE, ProductDict.WARRANTY_TYPE_OUT);
//        } else {
//            isSupport = productBService.checkTariffByProductIdAndShowType(showProductId, channelId, ProductConsts.EC_PRODUCT_TYPE, ProductDict.WARRANTY_TYPE_OUT);
//        }
//        return isSupport;
//    }
//
//    /**
//     * 描述: 提交执行配置信息，先检查该渠道是否有配置，如没有则新增，
//     *
//     * @param channelPriceVO
//     *            执行配置信息
//     * @param staff
//     *            系统当前用户
//     * @author wangjie
//     * @since 18:22 2019/7/7
//     **/
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void submitOnePrice(ChannelPriceVO channelPriceVO, LoginStaff staff) {
//
//        try {
//
//            ChannelPrice oldChannelPrice;
//            List<ChannelPriceCity> oldPriceCity;
//            Integer channelPriceId = channelPriceVO.getChannelPriceId();
//            if (Objects.nonNull(channelPriceId)) {
//                // 旧的执行城市配置
//                oldChannelPrice = channelPriceService.findByKey(channelPriceId);
//
//                // 数据库的执行配置数据
//                ChannelPriceCityQuery query = new ChannelPriceCityQuery();
//                query.setChannelPriceId(channelPriceId);
//                oldPriceCity = channelPriceCityService.listByQuery(query);
//
//                // 修改 先删除后新增
//                channelPriceCityService.deleteByChannelPriceId(channelPriceId);
//            } else {
//                // 新的执行城市配置
//                oldChannelPrice = new ChannelPrice();
//                oldPriceCity = Collections.emptyList();
//            }
//            ChannelPrice newChannelOnePrice = this.addModifyChannelOnePrice(channelPriceVO, staff.getRealName());
//            // 添加执行城市数据
//            this.addChannelOnePriceCity(channelPriceVO, newChannelOnePrice.getChannelPriceId(), staff.getRealName());
//            // 写入操作日志
//            this.addChannelOnePriceLog(oldPriceCity, oldChannelPrice, newChannelOnePrice, staff.getRealName(), staff.getStaffId(), channelPriceVO);
//        } catch (Exception e) {
//
//            logger.error(" 提交执行配置信息失败,数据回滚:Exception{},msg{}", e, e.getMessage());
//            throw new RuntimeException(e);
//        }
//    }
//
//    /**
//     * 描述: 检查是否有渠道执行配置数据
//     * <p>
//     * 有返回true,没有返回false
//     *
//     * @param channelId
//     *            渠道id
//     * @return java.lang.Boolean
//     * @author wangjie
//     * @since 18:26 2019/7/7
//     **/
//    @Override
//    public List<ChannelPrice> checkChannelOnePrice(Integer channelId) {
//
//        if (Objects.isNull(channelId)) {
//            throw new NullPointerException("channelId is null");
//        }
//        ChannelPriceQuery query = new ChannelPriceQuery();
//        query.setChannelId(channelId);
//        return Optional.ofNullable(channelPriceService.listPageByQuery(query)).orElse(Collections.emptyList());
//    }
//
//    @Override
//    public void modifyServiceCategory(Integer configId, Integer servCategId, Integer type, Integer showType, List<String> categoryIds, String operator) {
//        if (configId == null) {
//            return;
//        }
//
//        // 校验渠道试点配置前台分类
//        if (ProductConsts.EC_PRODUCT_TYPE.equals(showType)) {
//            // checkTariffStatus(categoryIds);
//            judgeUpProduct(servCategId, showType, categoryIds);
//            checkCategorySatisfyFaultRule(configId, type, categoryIds);
//        }
//        channelPriceCategoryService.deleteByConfigIdAndServCategId(configId, servCategId, type, showType);
//
//        if (categoryIds.size() > 0) {
//            List<ChannelPriceCategory> insertBatch = new ArrayList<>(categoryIds.size());
//            categoryIds.forEach(categoryId -> {
//                String[] ids = categoryId.split("-");
//                Integer newServCategId = Integer.valueOf(ids[0]);
//                Integer categOneId = Integer.valueOf(ids[1]);
//                Integer categId = Integer.valueOf(ids[2]);
//                ChannelPriceCategory channelPriceCategory = new ChannelPriceCategory(null, configId, type, showType, newServCategId, categOneId, categId, operator, null, DateUtil.getNow(), null);
//                insertBatch.add(channelPriceCategory);
//            });
//            channelPriceCategoryService.insertBatch(insertBatch);
//        }
//    }
//
//    /**
//     * 校验渠道配置，城市配置 开通前台品类是否满足计价器关系
//     * @param type 配置类型 1渠道配置 2城市配置
//     */
//    private void checkCategorySatisfyFaultRule(Integer configId, Integer type, List<String> showCategoryIds) {
//
//        ChannelPrice channelPrice = channelPriceService.findByKey(configId);
//        Integer channelId = 0;
//        if (channelPrice != null && channelPrice.getChannelId() != null) {
//            channelId = channelPrice.getChannelId();
//        }
//        if (Objects.equals(OnePriceConsts.CHANNEL_TYPE, type) && channelPrice != null && OnePriceConsts.TARIFF != channelPrice.getType()) {
//            return;
//        }
//        if (Objects.equals(OnePriceConsts.CITY_TYPE, type)) {
//            ServCityPrice servCityPrice = servCityPriceService.findByKey(configId);
//            if (servCityPrice != null && OnePriceConsts.TARIFF != servCityPrice.getType()) {
//                return;
//            }
//        }
//        List<ServProduct> servProducts = servProductService.listShowProductSatisfyFaultRule(channelId);
//        ServAssCategoryQuery showCategoryQuery = new ServAssCategoryQuery();
//        showCategoryQuery.setCategOneStatus(GlobalConsts.YES);
//        showCategoryQuery.setCategTwoStatus(GlobalConsts.YES);
//        showCategoryQuery.setServCategShowStatus(GlobalConsts.YES);
//        showCategoryQuery.setShowType(ProductConsts.EC_PRODUCT_TYPE);
//        // 启用的前台分类
//        Map<String, ServAssCategoryVO> showCategoryMap = servAssCategoryService.listByQuery(showCategoryQuery).stream()
//            .collect(Collectors.toMap(item -> item.getServCategId() + "-" + item.getCategOneId() + "-" + item.getCategId(), item -> item, (p, u) -> p));
//
//        Map<String, List<ServProduct>> resultMap = servProducts.stream().collect(Collectors.groupingBy(item -> item.getServCategId() + "-" + item.getCategOneId() + "-" + item.getCategId()));
//
//        StringBuffer stringBuffer = new StringBuffer();
//        for (String categoryId : showCategoryIds) {
//            ServAssCategoryVO showCategory = showCategoryMap.get(categoryId);
//            if (resultMap.get(categoryId) == null) {
//                stringBuffer.append(showCategory.getServCategName()).append("-");
//                stringBuffer.append(showCategory.getCategOneName()).append("-");
//                stringBuffer.append(showCategory.getCategName());
//                stringBuffer.append("、");
//            }
//        }
//
//        if (stringBuffer.toString().length() > 0) {
//            stringBuffer.deleteCharAt(stringBuffer.length() - 1);
//            throw new PlatException(String.format(
//                "【<span style='color:red;'>%s</span>】前台产品分类下：必须存在可用于计价器的关系，需满足以下条件：<br>1、上架的前台产品关联的上架的后台产品至少有一个 计价器状态是启用的<br>2、该后台产品至少关联一个已上架的计价器产品<br>3、该后台产品的保外计价器价格表：价格表为启用状态并且有启用中的项目",
//                stringBuffer.toString()));
//        }
//    }
//
//    /**
//     * 需要校验 所选择的服务分类+二级产品分类下是否有已上架的前台产品
//     *
//     * @param servCategId
//     * @param showType
//     * @param categoryIds
//     */
//    private void judgeUpProduct(Integer servCategId, Integer showType, List<String> categoryIds) {
//        ServProductQuery servProductQuery = new ServProductQuery();
//        servProductQuery.setShowType(showType);
//        servProductQuery.setServCategId(servCategId);
//        servProductQuery.setStatus(GlobalConsts.YES);
//        List<ServProduct> servProducts = servProductService.listByQuery(servProductQuery);
//        List<String> upProductCategIds = servProducts.stream().map(item -> item.getServCategId() + "-" + item.getCategOneId() + "-" + item.getCategId()).collect(Collectors.toList());
//        List<String> tipsCategIds = categoryIds.stream().filter(item -> !upProductCategIds.contains(item)).collect(Collectors.toList());
//        List<Integer> twoCategoryIds = new ArrayList<>();
//        ServCategory servCategory = servCategoryService.findByKey(servCategId);
//        String servCategName = "";
//        if (servCategory != null) {
//            if (showType.equals(ProductConsts.ERP_PRODUCT_TYPE)) {
//                servCategName = servCategory.getName();
//            } else {
//                servCategName = servCategory.getShowName();
//            }
//        }
//
//        if (tipsCategIds != null && tipsCategIds.size() > 0) {
//            for (String tipsCategId : tipsCategIds) {
//                String[] ids = tipsCategId.split("-");
//                twoCategoryIds.add(Integer.valueOf(ids[2]));
//            }
//            BaseCategoryQuery baseCategoryQuery = new BaseCategoryQuery();
//            baseCategoryQuery.setCategIds(twoCategoryIds);
//            List<BaseCategory> baseCategories = baseCategoryService.listByQuery(baseCategoryQuery);
//            StringBuffer tips = new StringBuffer();
//            for (int i = 0; i < baseCategories.size(); i++) {
//                tips.append(servCategName).append("-");
//                tips.append(baseCategories.get(i).getParentName()).append("-");
//                tips.append(baseCategories.get(i).getName());
//                if (i < baseCategories.size() - 1) {
//                    tips.append("、");
//                }
//            }
//
//            String productTipStr = "";
//            if (showType.equals(ProductConsts.ERP_PRODUCT_TYPE)) {
//                productTipStr = "后台产品";
//            } else {
//                productTipStr = "前台产品";
//            }
//
//            throw new PlatException(String.format("【<span style='color:red;'>%s</span>】产品分类下无上架的%s，请设置", tips.toString(), productTipStr));
//        }
//    }
//
//    private void checkTariffStatus(List<String> categoryIds) {
//        // 校验前台产品分类
//        checkCategoryTariffStatus(categoryIds);
//    }
//
//    private void checkCategoryTariffStatus(List<String> showCategoryIds) {
//
//        ServAssCategoryQuery showCategoryQuery = new ServAssCategoryQuery();
//        showCategoryQuery.setCategOneStatus(GlobalConsts.YES);
//        showCategoryQuery.setCategTwoStatus(GlobalConsts.YES);
//        showCategoryQuery.setServCategShowStatus(GlobalConsts.YES);
//        showCategoryQuery.setShowType(ProductConsts.EC_PRODUCT_TYPE);
//
//        // 启用的前台分类
//        Map<String, ServAssCategoryVO> showCategoryMap = servAssCategoryService.listByQuery(showCategoryQuery).stream()
//            .collect(Collectors.toMap(item -> item.getServCategId() + "-" + item.getCategOneId() + "-" + item.getCategId(), item -> item, (p, u) -> p));
//
//        showCategoryQuery.setCategOneTariffStatus(GlobalConsts.YES);
//        showCategoryQuery.setCategTwoTariffStatus(GlobalConsts.YES);
//        showCategoryQuery.setServCategShowTariffStatus(GlobalConsts.YES);
//
//        // 启用计价器状态的前台分类
//        Map<String, ServAssCategoryVO> checkShowTariffCategoryMap = servAssCategoryService.listByQuery(showCategoryQuery).stream()
//            .collect(Collectors.toMap(item -> item.getServCategId() + "-" + item.getCategOneId() + "-" + item.getCategId(), item -> item, (p, u) -> p));
//
//        ServAssCategoryQuery categoryQuery = new ServAssCategoryQuery();
//        categoryQuery.setCategOneStatus(GlobalConsts.YES);
//        categoryQuery.setCategTwoStatus(GlobalConsts.YES);
//        categoryQuery.setServCategStatus(GlobalConsts.YES);
//        categoryQuery.setShowType(ProductConsts.ERP_PRODUCT_TYPE);
//        categoryQuery.setCategOneTariffStatus(GlobalConsts.YES);
//        categoryQuery.setCategTwoTariffStatus(GlobalConsts.YES);
//
//        // 启用计价器状态的后台分类
//        Map<String, ServAssCategoryVO> checkTariffCategoryMap = servAssCategoryService.listByQuery(categoryQuery).stream()
//            .collect(Collectors.toMap(item -> item.getServCategId() + "-" + item.getCategOneId() + "-" + item.getCategId(), item -> item, (p, u) -> p));
//
//        // 前台分类对应的后台分类
//        Map<String, List<ShowCategoryAssociation>> byCategShowCategoryAssociationMap =
//            showCategoryAssociationService.listAll().stream().collect(Collectors.groupingBy(item -> item.getShowServCategId() + "-" + item.getShowCategOneId() + "-" + item.getShowCategId()));
//
//        // 查询全部产品
//        List<ServProduct> servProducts = servProductService.listAll();
//
//        // 分类对应产品
//        Map<String, List<ServProduct>> byCategServProductMap =
//            servProducts.stream().collect(Collectors.groupingBy(item -> item.getServCategId() + "-" + item.getCategOneId() + "-" + item.getCategId()));
//
//        // 产品映射
//        Map<Integer, ServProduct> servProductMap = servProducts.stream().collect(Collectors.toMap(item -> item.getProductId(), item -> item, (p, u) -> p));
//
//        // 前台产品与后台产品的映射关系
//        Map<Integer, List<ServProductRelation>> byShowProductRelationMap =
//            servProductRelationService.listByQuery(null).stream().filter(item -> item.getShowProductId() != null).collect(Collectors.groupingBy(item -> item.getShowProductId()));
//
//        for (String categoryId : showCategoryIds) {
//            ServAssCategoryVO showCategory = showCategoryMap.get(categoryId);
//            ServAssCategoryVO checkShowTraiffCategory = checkShowTariffCategoryMap.get(categoryId);
//            if (checkShowTraiffCategory == null) {
//                throw new PlatException(String.format("【<span style='color:red;'>%s-%s-%s</span>】前台二级/一级/产品分类/服务分类的计价器状态是停用，请先启用", showCategory.getServCategName(), showCategory.getCategOneName(),
//                    showCategory.getCategName()));
//            }
//
//            boolean support = byCategShowCategoryAssociationMap.get(categoryId).stream()
//                .anyMatch(item -> checkTariffCategoryMap.get(item.getServCategId() + "-" + item.getCategOneId() + "-" + item.getCategId()) != null);
//            if (!support) {
//                throw new PlatException(String.format("【<span style='color:red;'>%s-%s-%s</span>】后台二级/一级/产品分类的计价器状态是停用，请先启用", showCategory.getServCategName(), showCategory.getCategOneName(),
//                    showCategory.getCategName()));
//            }
//
//            support = byCategServProductMap.get(categoryId).stream().filter(item -> Objects.equals(item.getShowType(), ProductConsts.EC_PRODUCT_TYPE))
//                .filter(item -> Objects.equals(item.getStatus(), GlobalConsts.YES)).anyMatch(item -> Objects.equals(item.getTariffStatus(), GlobalConsts.YES));
//            if (!support) {
//                throw new PlatException(String.format("【<span style='color:red;'>%s-%s-%s</span>】前台二级产品分类没有开通计价器状态的前台产品，请先设置", showCategory.getServCategName(), showCategory.getCategOneName(),
//                    showCategory.getCategName()));
//            }
//
//            support = byCategServProductMap.get(categoryId).stream().filter(item -> Objects.equals(item.getShowType(), ProductConsts.EC_PRODUCT_TYPE))
//                .filter(item -> Objects.equals(item.getStatus(), GlobalConsts.YES)).filter(item -> Objects.equals(item.getTariffStatus(), GlobalConsts.YES)).anyMatch(item -> {
//                    // 根据前台产品ID查询后台产品映射关系
//                    List<ServProductRelation> servProductRelations = byShowProductRelationMap.get(item.getProductId());
//                    // 校验前台产品对应所有后台产品其中一项支持计价器
//                    if (!CollectionUtils.isEmpty(servProductRelations)) {
//                        List<ServProduct> list = servProductRelations.stream().map(servProductRelation -> servProductMap.get(servProductRelation.getProductId())).collect(Collectors.toList());
//                        return list.stream().filter(servProduct -> Objects.equals(servProduct.getStatus(), GlobalConsts.YES))
//                            .anyMatch(servProduct -> Objects.equals(servProduct.getTariffStatus(), GlobalConsts.YES));
//                    }
//                    return false;
//
//                });
//            if (!support) {
//                throw new PlatException(String.format("【<span style='color:red;'>%s-%s-%s</span】前台二级产品分类下的产品没有开通计价器状态的后台产品，请先设置", showCategory.getServCategName(), showCategory.getCategOneName(),
//                    showCategory.getCategName()));
//            }
//        }
//    }
//
//    @Override
//    @Transactional(rollbackFor = Exception.class)
//    public void deleteLogicByKey(Integer channelPriceId, LoginStaff staff) {
//        ChannelPrice byKey = channelPriceService.findByKey(channelPriceId);
//        Objects.requireNonNull(byKey);
//        ChannelPrice deleteLogic = new ChannelPrice().setChannelPriceId(channelPriceId).setStatus(GlobalDict.STATUS_DISABLE).setDelete(GlobalDict.STATUS_DISABLE).setUpdateTime(DateUtil.getNow());
//        channelPriceService.updateByKey(deleteLogic);
//
//        ChannelPriceLog log = new ChannelPriceLog();
//        String content = "逻辑删除渠道执行配置";
//        log.setContent(content);
//        log.setAbutmenterType(3);
//        log.setRelationId(channelPriceId);
//        log.setCreateTime(DateUtil.getNow());
//        log.setAbutmenter(staff.getRealName());
//        log.setAbutmenterId(staff.getStaffId());
//        channelPriceLogService.insert(log);
//    }
//
//    /**
//     * 描述: 新增渠道执行信息 如失败则抛出异常,数据回滚
//     *
//     * @param channelPriceVo
//     *            执行配置信息
//     * @param updater
//     *            数据修改人
//     * @author wangjie
//     * @since 18:34 2019/7/7
//     **/
//    private ChannelPrice addModifyChannelOnePrice(ChannelPriceVO channelPriceVo, String updater) {
//        ChannelPrice map = BeanMapper.map(channelPriceVo, ChannelPrice.class);
//        map.setUpdater(updater);
//        Integer amountFen = Objects.isNull(map.getDeposit()) ? null : NumberUtil.convertMoneyToFen(map.getDeposit());
//
//        map.setDeposit(amountFen);
//        if (Objects.nonNull(channelPriceVo.getChannelPriceId())) {
//            //支付方式不为“下单必须支付”清空定金状态
//            if(!Objects.equals(map.getPayType(),GlobalConsts.NO)){
//                map.setDepositStatus(null);
//            }
//            channelPriceService.updateByKey(map);
//        } else {
//            map.setCreater(updater);
//            channelPriceService.insert(map);
//        }
//        this.initChannelPriceSev(channelPriceVo.getServCategList(), map.getChannelPriceId(), updater);
//        // 只有"下单时必须支付"
//        return map;
//    }
//
//    /**
//     * 描述: 初始化 渠道价与服务分类的关系 （先删后增）
//     *
//     * @param servCategList
//     *            服务分类id
//     * @param channelPriceId
//     *            渠道价 id
//     * @param operator
//     *            操作人
//     * @author wangjie
//     * @since 2019/9/6
//     **/
//    private void initChannelPriceSev(List<Integer> servCategList, Integer channelPriceId, String operator) {
//
//        channelPriceServService.deleteByChannelPriceId(channelPriceId);
//
//        List<ChannelPriceServ> channelPriceServList = servCategList.stream()
//            .map(mm -> ChannelPriceServ.builder().channelPriceId(channelPriceId).servCategId(mm).creater(operator).createTime(DateUtil.getNow()).build()).collect(Collectors.toList());
//        channelPriceServService.insertChannelPriceServList(channelPriceServList, operator);
//    }
//
//    /**
//     * 描述: 写入操作日志
//     *
//     * @param oldPriceCity
//     *            旧的渠道执行城市配置
//     * @param oldChannelPrice
//     *            旧的渠道执行配置
//     * @param newChannelPrice
//     *            新的渠道执行配置
//     * @param updater
//     *            操作人
//     * @param updaterId
//     *            操作人id
//     * @author wangjie
//     * @since 18:43 2019/7/7
//     **/
//    private void addChannelOnePriceLog(List<ChannelPriceCity> oldPriceCity, ChannelPrice oldChannelPrice, ChannelPrice newChannelPrice, String updater, Integer updaterId,
//        ChannelPriceVO channelPriceVo) throws Exception {
//        // 更新日志关联id
//        ChannelPrice map = BeanMapper.map(newChannelPrice, ChannelPrice.class);
//
//        ChannelPriceLog log = new ChannelPriceLog();
//        Map<String, String> compare = this.compare(oldChannelPrice, map);
//        StringBuilder stringBuilder = new StringBuilder();
//        new ArrayList<>(compare.values()).forEach(e -> {
//            stringBuilder.append(e);
//            stringBuilder.append("</br>");
//        });
//
//        String s = this.formatterPriceCityChange(oldPriceCity, oldChannelPrice.getChannelPriceId(), channelPriceVo);
//        stringBuilder.append(s);
//        log.setContent(stringBuilder.toString());
//        log.setAbutmenterType(3);
//        log.setRelationId(newChannelPrice.getChannelPriceId());
//        log.setCreateTime(DateUtil.getNow());
//        log.setAbutmenter(updater);
//        log.setAbutmenterId(updaterId);
//        channelPriceLogService.insert(log);
//    }
//
//    /**
//     * 描述: 新增渠道执行对应城市信息
//     *
//     * @param channelPriceVo
//     *            执行配置信息
//     * @param updater
//     *            数据修改人
//     * @param channelPriceId
//     *            渠道执行id
//     * @author wangjie
//     * @since 18:47 2019/7/7
//     **/
//    private void addChannelOnePriceCity(ChannelPriceVO channelPriceVo, Integer channelPriceId, String updater) {
//
//        // 执行执行城市
//        String channelCityIdStr = "";
//        if (StringUtil.isNotBlank(channelPriceVo.getChannelPriceCityId())) {
//            channelCityIdStr = channelPriceVo.getChannelPriceCityId();
//        }
//        // 不执行城市
//        String channelBaseCityStr = "";
//        if (StringUtil.isNotBlank(channelPriceVo.getChannelBaseCityId())) {
//            channelBaseCityStr = channelPriceVo.getChannelBaseCityId();
//        }
//        ArrayList<ChannelPriceCity> collect = Lists.newArrayList();
//        // 收集执行城市保存
//        List<ChannelPriceCity> channelPriceCity = this.collectPriceCities(channelCityIdStr, channelPriceId, updater, OnePriceConsts.SUPPORT_CITY);
//        collect.addAll(channelPriceCity);
//        List<ChannelPriceCity> channelBaseCity = this.collectPriceCities(channelBaseCityStr, channelPriceId, updater, OnePriceConsts.NOT_SUPPORT_CITY);
//        collect.addAll(channelBaseCity);
//        if (!CollectionUtils.isEmpty(collect)) {
//            channelPriceCityService.insertAll(collect);
//        }
//    }
//
//    /**
//     * 描述: 格式化翻译城市信息数据
//     *
//     * @param str
//     *            执行城市str or 不执行城市
//     * @return java.util.Map<java.lang.Integer , java.lang.String>
//     * @author wangjie
//     * @since 19:47 2019/7/7
//     **/
//    private Map<Integer, String> formatterAreaStrToList(String str) {
//
//        ArrayList<Integer> arrayList = Lists.newArrayList();
//        Optional.of(Arrays.asList(str.split(","))).orElse(Collections.emptyList()).stream().map(e -> Arrays.asList(e.split("&"))).distinct().forEach(list -> {
//            List<Integer> collect = list.stream().map(Integer::parseInt).distinct().collect(Collectors.toList());
//            arrayList.addAll(collect);
//        });
//        return Optional.ofNullable(baseAreaService.findByKeys(arrayList)).orElse(Collections.emptyList()).stream().collect(Collectors.toMap(BaseArea::getAreaId, BaseArea::getName));
//    }
//
//    /**
//     * 描述: 收集城市执行 or 执行标准城市价
//     *
//     * @param channelCityIdStr
//     *            城市执行 or 执行标准城市价数据
//     * @param channelPriceId
//     *            渠道执行id
//     * @param updater
//     *            数据修改人
//     * @return java.util.List<com.zmn.plat.model.entity.oneprice.ChannelPriceCity>
//     * @author wangjie
//     * @since 19:50 2019/7/7
//     **/
//    private List<ChannelPriceCity> collectPriceCities(String channelCityIdStr, Integer channelPriceId, String updater, Integer operationType) {
//
//        if (StringUtil.isBlank(channelCityIdStr)) {
//            return Collections.emptyList();
//        }
//        Map<Integer, String> areaMap = this.formatterAreaStrToList(channelCityIdStr);
//
//        return Optional.of(Arrays.asList(channelCityIdStr.split(","))).orElse(Collections.emptyList()).stream().map(mm -> {
//            List<String> stringList = Arrays.asList(mm.split("&"));
//            if (stringList.size() >= GlobalConsts.NO) {
//                ChannelPriceCity channelPriceCity = new ChannelPriceCity();
//                channelPriceCity.setChannelPriceId(channelPriceId);
//                int provinceId = Integer.parseInt(stringList.get(GlobalConsts.NONE));
//                channelPriceCity.setProvinceId(provinceId);
//                channelPriceCity.setProvinceName(areaMap.get(provinceId));
//                if (stringList.size() == GlobalConsts.YES) {
//                    int cityId = Integer.parseInt(stringList.get(GlobalConsts.NO));
//                    channelPriceCity.setCityId(cityId);
//                    channelPriceCity.setCityName(areaMap.get(cityId));
//                }
//                channelPriceCity.setType(operationType);
//                channelPriceCity.setCreater(updater);
//                channelPriceCity.setCreateTime(DateUtil.getNow());
//                return channelPriceCity;
//            }
//            return null;
//        }).collect(Collectors.toList());
//    }
//
//    /**
//     * 描述: 检查2个对象间不同
//     *
//     * @param obj1
//     *            对象1
//     * @param obj2
//     *            对象2
//     * @return java.util.Map<java.lang.String>
//     * @author wangjie
//     * @since 22:05 2019/7/7
//     **/
//    private <T> Map<String, String> compare(T obj1, T obj2) throws Exception {
//
//        Map<String, String> result = Maps.newHashMap();
//        Field[] fs = obj1.getClass().getDeclaredFields();
//        for (Field f : fs) {
//            f.setAccessible(true);
//            Object v1 = f.get(obj1);
//            Object v2 = f.get(obj2);
//            if (!this.equals(v1, v2)) {
//                String operation = "编辑";
//                if (Objects.isNull(v1)) {
//                    operation = "新增";
//                }
//                String change = "新增".equals(operation) ? "" : "变更为";
//                switch (f.getName()) {
//                    case "payType":
//                        result.put("payType", operation + "支付方式：" + OnePriceDict.getPayType(Integer.parseInt(Optional.ofNullable(v1).orElse("0").toString())) + change
//                            + OnePriceDict.getPayType(Integer.parseInt(Optional.ofNullable(v2).orElse("0").toString())));
//                        break;
//                    // case "priceDiscount":
//                    //     result.put("priceDiscount", operation + "执行优惠：" + OnePriceDict.getPriceDiscount(Integer.parseInt(Optional.ofNullable(v1).orElse("0").toString())) + change
//                    //         + OnePriceDict.getPriceDiscount(Integer.parseInt(Optional.ofNullable(v2).orElse("0").toString())));
//                    //     break;
//                    case "status":
//                        result.put("status", operation + "状态：" + OnePriceDict.getStatus(Integer.parseInt(Optional.ofNullable(v1).orElse("0").toString())) + change
//                            + OnePriceDict.getStatus(Integer.parseInt(Optional.ofNullable(v2).orElse("0").toString())));
//                        break;
//                    default:
//                        break;
//                }
//            }
//        }
//        return result;
//    }
//
//    /**
//     * 描述: 对比
//     *
//     * @param obj1
//     *            对象1
//     * @param obj2
//     *            对象2
//     * @return boolean
//     * @author wangjie
//     * @since 22:05 2019/7/7
//     **/
//    private boolean equals(Object obj1, Object obj2) {
//
//        if (obj1 == obj2) {
//            return true;
//        }
//        if (obj1 == null || obj2 == null) {
//            return false;
//        }
//        return obj1.equals(obj2);
//    }
//
//    /**
//     * 描述: 格式化城市配置操作日志
//     *
//     * @param oldPriceCity
//     *            旧的渠道执行城市配置
//     * @param oldChannelPriceId
//     *            配置id
//     * @param channelPriceVo
//     *            新对象
//     * @return java.lang.String
//     * @author wangjie
//     * @since 11:31 2019/7/8
//     **/
//    private String formatterPriceCityChange(List<ChannelPriceCity> oldPriceCity, Integer oldChannelPriceId, ChannelPriceVO channelPriceVo) {
//
//        StringBuilder sb = new StringBuilder();
//        if (Objects.isNull(oldChannelPriceId)) {
//            // 确认该城市配置数据为新增
//            this.appendPriceCity(sb, oldChannelPriceId, channelPriceVo);
//        } else {
//            // 确认该城市配置数据为修改
//            this.modifyPriceCity(oldPriceCity, sb, oldChannelPriceId, channelPriceVo);
//        }
//        return sb.toString();
//    }
//
//    /**
//     * 描述: 确认该城市配置数据为新增 日志收集
//     *
//     * @param sb
//     *            日志描述字符串
//     * @param oldChannelPriceId
//     *            配置id
//     * @param channelPriceVo
//     *            新对象
//     * @author wangjie
//     * @since 11:29 2019/7/8
//     **/
//    private void appendPriceCity(StringBuilder sb, Integer oldChannelPriceId, ChannelPriceVO channelPriceVo) {
//        // 收集执行城市保存
//        List<ChannelPriceCity> onePrice = this.collectPriceCities(channelPriceVo.getChannelPriceCityId(), oldChannelPriceId, "", OnePriceConsts.SUPPORT_CITY);
//        if (!CollectionUtils.isEmpty(onePrice)) {
//            sb.append("新增执行城市：");
//            onePrice.forEach(e -> {
//                sb.append(Optional.ofNullable(e.getProvinceName()).orElse(""));
//                sb.append(Optional.ofNullable(e.getCityName()).orElse(""));
//                sb.append("、");
//            });
//            sb.append("</br>");
//        }
//        // 收集不执行城市保存
//        List<ChannelPriceCity> channelPriceCities = this.collectPriceCities(channelPriceVo.getChannelBaseCityId(), oldChannelPriceId, "", OnePriceConsts.NOT_SUPPORT_CITY);
//        if (!CollectionUtils.isEmpty(channelPriceCities)) {
//            sb.append("新增不执行城市：");
//            channelPriceCities.forEach(e -> {
//                sb.append(Optional.ofNullable(e.getProvinceName()).orElse(""));
//                sb.append(Optional.ofNullable(e.getCityName()).orElse(""));
//                sb.append("、");
//            });
//        }
//    }
//
//    /**
//     * 描述: 格式化操作日志
//     *
//     * @param oldPriceCity
//     *            就是配置数据
//     * @param sb
//     *            日志记录容器
//     * @param oldChannelPriceId
//     *            旧的配置id
//     * @param channelPriceVo
//     *            新的数据
//     * @author wangjie
//     * @since 16:16 2019/7/8
//     **/
//    private void modifyPriceCity(List<ChannelPriceCity> oldPriceCity, StringBuilder sb, Integer oldChannelPriceId, ChannelPriceVO channelPriceVo) {
//
//        // 页面传入的执行配置数据
//        List<ChannelPriceCity> newPriceCity = this.collectPriceCities(channelPriceVo.getChannelPriceCityId(), oldChannelPriceId, "", OnePriceConsts.SUPPORT_CITY);
//        String s = this.formatterModifyPriceCityStr(oldPriceCity, newPriceCity, OnePriceConsts.SUPPORT_CITY);
//        if (StringUtil.isNotBlank(s)) {
//            sb.append("编辑执行城市：").append(s).append("</br>");
//        }
//        // 页面传入的不执行配置数据
//        List<ChannelPriceCity> newBasePriceCity = this.collectPriceCities(channelPriceVo.getChannelBaseCityId(), oldChannelPriceId, "", OnePriceConsts.NOT_SUPPORT_CITY);
//        String s1 = this.formatterModifyPriceCityStr(oldPriceCity, newBasePriceCity, OnePriceConsts.NOT_SUPPORT_CITY);
//        if (StringUtil.isNotBlank(s1)) {
//            sb.append("编辑不执行城市：").append(s1).append("</br>");
//        }
//    }
//
//    /**
//     * 描述: 格式化新旧数据记录日志
//     *
//     * @param oldPriceCity
//     *            旧的数据
//     * @param newPriceCity
//     *            新的数据
//     * @param operationType
//     *            操作类型
//     * @return java.lang.String
//     * @author wangjie
//     * @since 16:14 2019/7/8
//     **/
//    private String formatterModifyPriceCityStr(List<ChannelPriceCity> oldPriceCity, List<ChannelPriceCity> newPriceCity, Integer operationType) {
//        StringBuilder oldSb = new StringBuilder();
//        oldPriceCity.stream().filter(ff -> Objects.equals(ff.getType(), operationType)).forEach(e -> {
//            if (StringUtil.isNotBlank(e.getCityName())) {
//                oldSb.append("\"").append(e.getProvinceName());
//                oldSb.append(e.getCityName()).append("\"");
//            } else {
//                oldSb.append("\"").append(e.getProvinceName()).append("\"");
//            }
//            oldSb.append(",");
//        });
//        StringBuilder newSb = new StringBuilder();
//        newPriceCity.forEach(e -> {
//
//            if (StringUtil.isNotBlank(e.getCityName())) {
//                newSb.append("\"").append(e.getProvinceName());
//                newSb.append(e.getCityName()).append("\"");
//            } else {
//                newSb.append("\"").append(e.getProvinceName()).append("\"");
//            }
//            newSb.append(",");
//        });
//        if (Objects.equals(oldSb.toString(), newSb.toString())) {
//            return "";
//        } else {
//            String newSbStr = StringUtil.isBlank(newSb.toString()) ? "\"无\"" : newSb.toString();
//            String oldSbStr = StringUtil.isBlank(oldSb.toString()) ? "\"无\"" : oldSb.toString();
//            return oldSbStr + "变更为" + newSbStr;
//        }
//    }
//
//    /**
//     * 描述：城市级别是否支持计价器试点
//     * @param cityId
//     * @param queryList
//     * @author tanbiao
//     * @since 2020/12/24 13:46
//     * @return java.util.List<com.zmn.plat.model.entity.oneprice.SupportTariffCategoryVO>
//     * @modifier
//     */
//    private List<SupportTariffCategoryVO> listSupportTariffByCityIdAndCategIds(Integer cityId, List<ChannelPriceSupportCategoryQuery> queryList) {
//        List<ServCityPrice> servCityPriceList = servCityPriceService.listByCityIdAndType(cityId,GlobalConsts.YES);
//        // 城市未配置
//        if(CollectionUtils.isEmpty(servCityPriceList)){
//            return Lists.newArrayList();
//        }
//        // 城市配置，查询城市下的分类是否满足条件
//        List<Integer> configIdList = servCityPriceList.stream().map(e->e.getRelationId()).collect(Collectors.toList());
//        return listSupportTariffCategoryByConfigIdsAndCategIds(GlobalConsts.YES,configIdList,queryList);
//    }
//
//    /**
//     * 描述：分类是否满足试点要求
//     * @param configIds：渠道或者城市配置的id
//     * @param type:1渠道计价器故障维度-配置ID 2城市计价器故障维度-配置ID
//     * @param queryList:服务分类和产品分类的对应关系
//     * @author tanbiao
//     * @since 2020/12/24 14:34
//     * @return java.util.List<com.zmn.plat.model.entity.oneprice.SupportTariffCategoryVO>
//     * @modifier
//     */
//    private List<SupportTariffCategoryVO> listSupportTariffCategoryByConfigIdsAndCategIds(Integer type,List<Integer> configIds,List<ChannelPriceSupportCategoryQuery> queryList){
//        List<ChannelPriceCategory> list = channelPriceCategoryService.listByTypeAndConfiIdsAndCategIds(type,configIds,queryList);
//        if(CollectionUtils.isEmpty(list)){
//            return Lists.newArrayList();
//        }
//
//        List<SupportTariffCategoryVO> retList =list.stream().map(e->{
//            SupportTariffCategoryVO vo = new SupportTariffCategoryVO();
//            vo.setServCategId(e.getServCategId());
//            vo.setCategOneId(e.getCategOneId());
//            vo.setCategTwoId(e.getCategId());
//            vo.setType(e.getType());
//            return vo;
//        }).collect(Collectors.toList());
//        return retList;
//    }
//
//
//
//
//
//
//
//
//
//
//    /**
//     * 描述：城市级别是否支持计价器试点
//     * @param cityId
//     * @author tanbiao
//     * @since 2020/12/24 13:46
//     * @return java.util.List<com.zmn.plat.model.entity.oneprice.SupportTariffCategoryVO>
//     * @modifier
//     */
//    private List<SupportTariffCategoryVO> listSupportTariffByCityId(Integer cityId) {
//        List<ServCityPrice> servCityPriceList = servCityPriceService.listByCityIdAndType(cityId,GlobalConsts.YES);
//        // 城市未配置
//        if(CollectionUtils.isEmpty(servCityPriceList)){
//            return Lists.newArrayList();
//        }
//        // 城市配置，查询城市下的分类是否满足条件
//        List<Integer> configIdList = servCityPriceList.stream().map(e->e.getRelationId()).collect(Collectors.toList());
//        return listSupportTariffCategoryByConfigIds(GlobalConsts.YES,configIdList);
//    }
//
//
//    /**
//     * 描述：分类是否满足试点要求
//     * @param configIds：渠道或者城市配置的id
//     * @param type:1渠道计价器故障维度-配置ID 2城市计价器故障维度-配置ID
//     * @author tanbiao
//     * @since 2020/12/24 14:34
//     * @return java.util.List<com.zmn.plat.model.entity.oneprice.SupportTariffCategoryVO>
//     * @modifier
//     */
//    private List<SupportTariffCategoryVO> listSupportTariffCategoryByConfigIds(Integer type,List<Integer> configIds){
//        List<ChannelPriceCategory> list = channelPriceCategoryService.listByTypeAndConfiIdsAndCategIds(type,configIds,null);
//        if(CollectionUtils.isEmpty(list)){
//            return Lists.newArrayList();
//        }
//
//        List<SupportTariffCategoryVO> retList =list.stream().map(e->{
//            SupportTariffCategoryVO vo = new SupportTariffCategoryVO();
//            vo.setServCategId(e.getServCategId());
//            vo.setCategOneId(e.getCategOneId());
//            vo.setCategTwoId(e.getCategId());
//            vo.setType(e.getType());
//            return vo;
//        }).collect(Collectors.toList());
//        return retList;
//    }
//
//}